home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / edit / pt20pc.zip / FILEIO.C < prev    next >
C/C++ Source or Header  |  1991-02-04  |  16KB  |  648 lines
  1. #include "pt.h"
  2. #include "memory.h"
  3. #include "malloc.h"
  4. #include "string.h"
  5. #include "direct.h"
  6. #include "io.h"
  7. #include "process.h"
  8. #include "conio.h"
  9.  
  10. extern struct openFile *files;
  11. extern struct diskBuffer *buffers;
  12. extern struct diskBuffer *bufHash[];
  13. extern nextBuffer;
  14.  
  15. void pascal
  16. /* XTAG:initFileio */
  17. initFileio()
  18. {
  19.     extern unsigned char msgBuffer[];
  20.     extern struct piece *freePList;
  21.     extern struct piece pieceTable[];
  22.     extern unsigned char *bufferSpace;
  23.     extern int nBuffers;
  24.     extern unsigned int piecesLeft;
  25.     extern unsigned int bytesLeft;
  26.     extern unsigned int maxFiles;
  27.     extern unsigned int debug;
  28.     extern unsigned char *userMessages[];
  29.     
  30.     register int i;
  31.     unsigned short segIncrement, *segPointer;
  32.     long size;
  33.     unsigned char huge *bs;
  34.  
  35.     for(i = 0; i < maxFiles; i++) {
  36.         files[i].origHandle = -1;
  37.     }
  38.  
  39.     /* set up the buffer hash scheme */
  40.     for(i = 0; i < NBUFHASH; i++)
  41.         bufHash[i] = NULL;
  42.     nextBuffer = -1;
  43.  
  44.     /* allocate the space (out of this address space) for the buffers */
  45. retryAllocation:
  46.     size = (long)BUFFERSIZE * (long)nBuffers;
  47.     bs = halloc(size, 1);
  48.     if( bs == 0L ) {
  49.         /* if there is not enough space, try fewer buffers */
  50.         if( nBuffers >= 25 ) {
  51.             nBuffers -= 20;
  52.             goto retryAllocation;
  53.         }
  54.         size -= (unsigned)16*(unsigned)i;
  55.         cprintf(userMessages[NOBUFFERMEMORY], size);
  56.         exit(1);
  57.     }
  58.  
  59.     /* set up each buffer header to the segment address of the */
  60.     /* allocated buffer. Buffer i is at buffers[i].bufferAddress  */
  61.     segIncrement = (unsigned short)(BUFFERSIZE / 16);
  62.     for(i = 0; i < nBuffers; i++) {
  63.         buffers[i].handle = -1;
  64.         buffers[i].bufferAddress = (unsigned char far *)bs;
  65.         /***bs += BUFFERSIZE;***/
  66.         /* move the segment part of the address up */
  67.         segPointer = ((unsigned short *)(&bs)) + 1;
  68.         *segPointer += segIncrement;
  69.     }
  70.     
  71.     /* set up the free piece list */
  72.     freePList = NULL;
  73.     piecesLeft = 0;
  74.     bytesLeft = _memavl();
  75. }
  76.  
  77. int pascal
  78. /* XTAG:getFileId */
  79. getFileId(origName)
  80.     unsigned char *origName;
  81. {
  82.     extern unsigned char msgBuffer[];
  83.     extern unsigned char scratchFileName[];
  84.     extern int addHandle;
  85.     extern int readOnly;
  86.     extern int maxFiles;
  87.     extern int supressFileMsgs;
  88. #ifdef OVERLAYS
  89.     extern int filesToOpen;
  90.     extern struct openFile *ffsToOpen[];
  91. #endif
  92.     extern unsigned char *userMessages[];
  93.  
  94.     int fileNumber, origHandle;
  95.     int freeFileId;
  96.     long size;
  97.     register struct piece *pp;
  98.     register struct openFile *ff;
  99.     unsigned char *fullFilename;
  100.  
  101.     if( origName == NULL ) {
  102.         scratchFileName[0] = '\0';
  103.         fullFilename = &scratchFileName[0];
  104.     } else
  105.         fullFilename = makeFullPathname(origName);
  106.  
  107.     /* find a free file structure */
  108.     freeFileId = -1;
  109.     for(fileNumber = 0; fileNumber < maxFiles; fileNumber++) {
  110.         if( files[fileNumber].origHandle == -1 ) {
  111.             if( freeFileId == -1 )
  112.                 freeFileId = fileNumber;
  113.         } else if(
  114.             strcmpi(files[fileNumber].origName, fullFilename)
  115.                                 == 0 ) {
  116.             ++(files[fileNumber].useCount);
  117.             return fileNumber;
  118.         }
  119.     }
  120.     if( freeFileId == -1 ) {
  121.         msg(userMessages[OUTOFFILESTRUCT], 3);
  122.         return -1;
  123.     } else
  124.         fileNumber = freeFileId;
  125.  
  126.     /* open the original file */
  127.     ff = &files[fileNumber];
  128.     strncpy(ff->origName, fullFilename, FILENAMESIZE);
  129.     
  130.     if( fullFilename[0] == '\0' ) {
  131.         origHandle = addHandle;
  132.     } else {
  133.         origHandle = openls(fullFilename, 0);
  134.  
  135.         if( origHandle == -4 ) {
  136.             if( supressFileMsgs < 2 )
  137.                 msg(userMessages[HANDLEMSG], 3);
  138.             if( supressFileMsgs == 1 )
  139.                 supressFileMsgs = 2;
  140.             return -1;
  141.         } else if( origHandle < 0 ) {
  142.             sprintf(msgBuffer, userMessages[CANNOTOPEN],
  143.                 fullFilename);
  144.             msg(msgBuffer, 3);
  145.             return -1;
  146.         }
  147.  
  148. #ifdef OVERLAYS
  149.         /* see if we were called from an overlay any have to */
  150.         /* reopen the file after the overlay completes */
  151.         if( filesToOpen > 0 ) {
  152.             ffsToOpen[filesToOpen-1] = ff;
  153.             ++filesToOpen;
  154.         }
  155. #endif
  156.     }
  157.     ff->origHandle = origHandle;
  158.  
  159.     /* initialize the other fields */
  160.     if( origHandle != addHandle ) {
  161.         size = lseekls(origHandle, 0L, 2);
  162.         lseekls(origHandle, 0L, 0);
  163.     } else
  164.         size = 0;
  165.     ff->fileSize = size;
  166.     ff->origFileSize = size;
  167.     ff->useCount = 1;
  168.     ff->bakMade = 0;
  169.     ff->isChanged = 0;    /* has not been edited yet */
  170.     if( readOnly )
  171.         ff->readOnly = 1;
  172.     else if( origHandle == addHandle ) {
  173.         ff->readOnly = 0;
  174.     } else {
  175.         /* check for read and write permissions (6 => RW) */
  176.         /* edit in readOnly mode if the DOS file permissions */
  177.         /* do not allow writing the file */
  178.         ff->readOnly = (unsigned char)!(access(ff->origName, 6) == 0);
  179.     }
  180.  
  181.     /* initialize the piece table */
  182.     pp = getFreePiece();
  183.     pp->file = ORIGFILE;
  184.     pp->position = 0;
  185.     pp->length = size;
  186.     ff->pieceList = pp;
  187.  
  188.     /* initialize the optimization fields */
  189.     ff->loLogPiece = 0;
  190.     ff->hiLogPiece = size - 1;
  191.     ff->logPiece = pp;
  192.     ff->hiLogBuffer = -1L;
  193.     ff->logBufSegment = NULL;
  194.     ff->logBufOffset = NULL;
  195.  
  196.     /*return the fileId */
  197.     return fileNumber;
  198. }
  199.  
  200. void pascal
  201. /* XTAG:saveFile */
  202. saveFile(w)
  203.     struct window *w;
  204. {
  205.     extern unsigned char msgBuffer[];
  206.     extern struct openFile *files;
  207.     extern int addHandle;
  208. #ifdef OVERLAYS
  209.     extern int filesToOpen;
  210.     extern struct openFile *ffsToOpen[];
  211. #endif
  212.     extern unsigned char *userMessages[];
  213.  
  214.     register struct openFile *ff;
  215.     unsigned char *tempFile, *p;
  216.     int i;
  217.     long size;
  218.     struct piece *pp;
  219.  
  220.     ff = &files[w->fileId];
  221.     
  222.     if( ff->readOnly ) {
  223.         sprintf(msgBuffer, userMessages[READONLYFILE], ff->origName);
  224.         msg(msgBuffer, 3);
  225.         return;
  226.     }
  227.  
  228.     tempFile = makeTempFor(ff->origName);
  229.     sprintf(msgBuffer, userMessages[WRITINGFILE], ff->origName,
  230.         ff->fileSize);
  231.     msg(msgBuffer, 1);
  232.  
  233.     if( !doWrite(w->fileId, tempFile) )
  234.         return;
  235.  
  236.     sprintf(msgBuffer, userMessages[FILEWRITTEN], ff->origName,
  237.         ff->fileSize);
  238.     msg(msgBuffer, 1);
  239.  
  240.     /* invalidate any buffers allocated to this open file */
  241.     fidInvalid(ff->origHandle);
  242.     ff->hiLogBuffer = -1L;
  243.  
  244.     /* reset the change flag */
  245.     ff->isChanged = 0;
  246.  
  247.     /* close the original file for this open file */
  248.     if( ff->origHandle != addHandle ) {
  249.         i = closels(ff->origHandle);
  250.         if( i != 0 ) {
  251.             sprintf(msgBuffer, userMessages[CLOSEFAILED],
  252.                 ff->origName, i);
  253.             msg(msgBuffer, 3);
  254.         }
  255.     }
  256.  
  257.     if( !ff->bakMade ) {
  258.         /* generate the .bak name and rename the original file */
  259.         /* rename the temporary file we copied it into */
  260.         p = makeBak(ff->origName);
  261.         delete(p);    /* make sure any old .bak file is deleted */
  262.         if( renamels(ff->origName, p) ) {
  263.             sprintf(msgBuffer, userMessages[RENAMEFAILED],
  264.                 ff->origName, p, tempFile);
  265.             msg(msgBuffer, 3);
  266.         }
  267.         ff->bakMade = 1;
  268.     } else {
  269.         if( delete(ff->origName) ) {
  270.             sprintf(msgBuffer, userMessages[DELETEFAILED],
  271.                 ff->origName, tempFile);
  272.             msg(msgBuffer, 3);
  273.         }
  274.     }
  275.  
  276.     if( renamels(tempFile, ff->origName) ) {
  277.         sprintf(msgBuffer, userMessages[RENAMEFAILED2],
  278.             tempFile, ff->origName, ff->origName, tempFile);
  279.         msg(msgBuffer, 3);
  280.     }
  281.  
  282.     /* open it up again */
  283.     if( ff->origHandle != addHandle )
  284.         ff->origHandle = openls(ff->origName, 0);
  285.  
  286. #ifdef OVERLAYS
  287.     /* see if we were called from an overlay any have to reopen */
  288.     /* the file after the overlay completes */
  289.     if( filesToOpen > 0 ) {
  290.         ffsToOpen[filesToOpen-1] = ff;
  291.         ++filesToOpen;
  292.     }
  293. #endif
  294.  
  295.     /* re-initialize the other fields */
  296.     size = lseekls(ff->origHandle, 0L, 2);
  297.     ff->fileSize = size;
  298.     ff->origFileSize = size;
  299.     lseekls(ff->origHandle, 0L, 0);
  300.     
  301.     /* free all the pieces */
  302.     freePieces(ff->pieceList);
  303.  
  304.     /* re-initialize the piece table */
  305.     pp = getFreePiece();
  306.     ff->pieceList = pp;
  307.     pp->file = ORIGFILE;
  308.     pp->position = 0;
  309.     pp->length = size;
  310.  
  311.     /* re-initialize the optimization fields */
  312.     ff->loLogPiece = 0;
  313.     ff->hiLogPiece = size - 1;
  314.     ff->logPiece = pp;
  315.     ff->hiLogBuffer = -1L;
  316.     ff->logBufSegment = NULL;
  317.     ff->logBufOffset = NULL;
  318. }
  319.  
  320. unsigned char * pascal
  321. /* XTAG:makeBak */
  322. makeBak(s)
  323.     unsigned char *s;
  324. {
  325.     static unsigned char name[64];
  326.     register int i;
  327.     int len;
  328.  
  329.     /* find the extension (if there is one) */
  330.     len = strlen(s);
  331.     for(i = len - 1; i > 0 && s[i] != '.' && s[i] != '\\'; --i)
  332.         ;
  333.     if( s[i] != '.' )
  334.         /* if no extension t